Scala

Scala is a general purpose programming language designed to express common programming patterns in a concise, elegant, and type-safe way. It smoothly integrates features of object-oriented and functional languages. It is also fully interoperable with Java

Computer Code as a Medium for Human Communication: Are Programming Languages Improving?

Programming languages are not only useful to command computers, they also increasingly are a medium for human communication. I will use the framework of distributed cognition to discuss how knowledge is shared in a team of programmers and to show that computer code plays an important role in it. The resulting model of how programmers comprehend code suggests that common grounds play an important role in it. I propose two hypotheses concerning the means used by programmers to refer to common grounds from within their code. The hypotheses imply that modern languages, such as Scala, offer advantages as human communication mediums. I describe an experiment, using an eye-tracking device, that measures the performance of code comprehension. The hypotheses are tested by varying the degree of reference to common grounds

Better Relational Queries using For-comprehensions

For-comprehensions, an operator to apply expressions on selected elements of sets or lists, can replace most of SQL as a query language. I present my current and future work on integrating for-comprehensions for database access in general-purpose programming languages without compromising on performance

Compiling structural types on the JVM: a comparison of reflective and generative techniques from Scala's perspective

This article describes Scala's compilation technique of structural types for the JVM. The technique uses Java reflection and polymorphic inline caches. Performance measurements of this technique are presented and analysed. Further measurements compare Scala's reflective technique with the "generative" technique used by Whiteoak to compile structural types. The article ends with a comparison of reflective and generative techniques for compiling structural types. It concludes that generative techniques may, in specific cases, exhibit higher performances than reflective approaches, but that reflective techniques are easier to implement and have fewer restrictions

An Overview of the Scala Programming Language (2. Edition)

Scala fuses object-oriented and functional programming in a statically typed programming language. It is aimed at the construction of components and component systems. This paper gives an overview of the Scala language for readers who are familar with programming methods and programming language design

HIV-1 Protease and Reverse Transcriptase Control the Architecture of Their Nucleocapsid Partner

The HIV-1 nucleocapsid is formed during protease (PR)-directed viral maturation, and is transformed into pre-integration complexes following reverse transcription in the cytoplasm of the infected cell. Here, we report a detailed transmission electron microscopy analysis of the impact of HIV-1 PR and reverse transcriptase (RT) on nucleocapsid plasticity, using in vitro reconstitutions. After binding to nucleic acids, NCp15, a proteolytic intermediate of nucleocapsid protein (NC), was processed at its C-terminus by PR, yielding premature NC (NCp9) followed by mature NC (NCp7), through the consecutive removal of p6 and p1. This allowed NC co-aggregation with its single-stranded nucleic-acid substrate. Examination of these co-aggregates for the ability of RT to catalyse reverse transcription showed an effective synthesis of double-stranded DNA that, remarkably, escaped from the aggregates more efficiently with NCp7 than with NCp9. These data offer a compelling explanation for results from previous virological studies that focused on i) Gag processing leading to nucleocapsid condensation, and ii) the disappearance of NCp7 from the HIV-1 pre-integration complexes. We propose that HIV-1 PR and RT, by controlling the nucleocapsid architecture during the steps of condensation and dismantling, engage in a successive nucleoprotein-remodelling process that spatiotemporally coordinates the pre-integration steps of HIV-1. Finally we suggest that nucleoprotein remodelling mechanisms are common features developed by mobile genetic elements to ensure successful replication

The SLinks Language

This report presents a prototype interpreter for a simple functional language, called SLinks. The focus of this work is two-fold. One side is the design of a type inference system, based on the Hindley-Milner algorithm, with additional support for record and variant types. This type system is similar to row variable based systems as described by Rémy and Wand. The other side is the support of database querying from within the language. In particular, the focus is on automatic optimisation of SLinks expressions into SQL queries. The resulting prototype, that tested and will be used to test techniques for Philip Wadler’s upcoming Links language, was heavily inspired by Wong’s Kleisi and CPL language. It does however extends it in various ways, in particular as far as record and variant operators are handled in typing and SQ

On Embedding Domain-specific Languages with User-friendly Syntax

I present ZyTyG, a strategy to define domain-specific languages with a user-friendly syntax. This strategy does not requires any pre-processor or metaprogramming facility and only relies on features provided by the object-oriented host language. I describe its application to ScalaDBC, a database library with an embedded DSL to encode queries in SQL-like syntax and that uses this strategy.

Improving API Documentation for Java-like Languages

The Javadoc paradigm for displaying API documentation to users is quite popular, with similar variants existing for many mainstream languages. However, two user interface design properties of Javadoc may reduce its utility when displaying documentation for APIs that make use of inheritance and parametric polymorphism. First, Javadoc does not show a flattened view of all members of a class or interface, but rather only those defined directly in the type. Second, and as a consequence, any methods whose types contain type parameters of a superclass will always be shown in the context of the superclass. That is, if the method C.m returns type T, subclasses of C will always see this parent signature, even if they instantiate T to a concrete type such as Integer. We show that this situation arises often in some libraries, and present the results of a study that measures the usability consequences of these two Javadoc design decisions. Our results show that a user interface that shows instantiated type parameters for members is preferred over one that presents type parameters in the Javadoc style. 1